/**
 * Vue.js 自动化版本发布脚本
 *
 * 这个脚本实现了完整的 Vue.js 项目版本发布流程，支持：
 * - 语义化版本管理 (Semantic Versioning)
 * - 交互式版本选择和确认
 * - Canary 版本自动生成（用于预发布测试）
 * - CI/CD 状态检查和集成
 * - 自动化 changelog 生成
 * - 跨包依赖版本同步
 * - npm 包发布和 Git 标签管理
 * - 干运行模式支持
 *
 * 使用场景：
 * - 正式版本发布（patch、minor、major）
 * - 预发布版本（alpha、beta、rc）
 * - Canary 版本（每日构建、特性验证）
 * - 本地测试和验证
 *
 * @ts-check
 */
import fs from 'node:fs'
import path from 'node:path'
import pico from 'picocolors'
import semver from 'semver'
import enquirer from 'enquirer'
import { createRequire } from 'node:module'
import { fileURLToPath } from 'node:url'
import { exec } from './utils.js'
import { parseArgs } from 'node:util'

/**
 * 包配置文件的类型定义
 * 用于 TypeScript 类型检查和 IDE 智能提示
 *
 * @typedef {{
 *   name: string                                                           // 包名
 *   version: string                                                        // 当前版本号
 *   dependencies?: { [dependenciesPackageName: string]: string }           // 生产依赖映射
 *   peerDependencies?: { [peerDependenciesPackageName: string]: string }  // 同级依赖映射
 * }} Package
 */

// 全局状态标记，用于错误处理时的版本回滚
let versionUpdated = false

// 导入 enquirer 的 prompt 函数用于交互式命令行界面
const { prompt } = enquirer

// 获取根目录 package.json 中的当前版本号
const currentVersion = createRequire(import.meta.url)('../package.json').version

// 获取脚本文件所在目录的绝对路径
const __dirname = path.dirname(fileURLToPath(import.meta.url))

// 解析命令行参数，配置所有可用的选项
// 支持位置参数（如版本号）和各种功能标志
const { values: args, positionals } = parseArgs({
  allowPositionals: true, // 允许位置参数（如直接指定版本号）
  options: {
    preid: {
      type: 'string', // 预发布版本标识（如 alpha, beta, rc）
    },
    dry: {
      type: 'boolean', // 干运行模式，只显示将要执行的命令而不实际执行
    },
    tag: {
      type: 'string', // npm 发布标签（如 latest, next, canary）
    },
    canary: {
      type: 'boolean', // Canary 版本发布模式
    },
    skipBuild: {
      type: 'boolean', // 跳过构建步骤
    },
    skipTests: {
      type: 'boolean', // 跳过测试执行
    },
    skipGit: {
      type: 'boolean', // 跳过 Git 操作（提交、标签、推送）
    },
    skipPrompts: {
      type: 'boolean', // 跳过交互式确认提示
    },
    publish: {
      type: 'boolean', // 是否立即发布到 npm（默认通过 CI 发布）
      default: false,
    },
    publishOnly: {
      type: 'boolean', // 仅执行发布操作，跳过其他步骤
    },
    registry: {
      type: 'string', // 自定义 npm registry 地址
    },
  },
})

// 预发布标识符，从参数或当前版本中获取
const preId = args.preid || semver.prerelease(currentVersion)?.[0]

// 是否为干运行模式
const isDryRun = args.dry

// 是否跳过测试（可能在运行时根据 CI 状态动态修改）
/** @type {boolean | undefined} */
let skipTests = args.skipTests

// 各种执行控制标志
const skipBuild = args.skipBuild // 是否跳过构建
const isCanary = args.canary // 是否为 Canary 版本
const skipPrompts = args.skipPrompts || args.canary // Canary 版本自动跳过提示
const skipGit = args.skipGit || args.canary // Canary 版本自动跳过 Git 操作

// 扫描 packages 目录，获取所有非私有包的列表
// 只包含需要发布到 npm 的公共包
const packages = fs
  .readdirSync(path.resolve(__dirname, '../packages'))
  .filter(p => {
    const pkgRoot = path.resolve(__dirname, '../packages', p)
    if (fs.statSync(pkgRoot).isDirectory()) {
      const pkg = JSON.parse(
        fs.readFileSync(path.resolve(pkgRoot, 'package.json'), 'utf-8'),
      )
      return !pkg.private // 过滤掉私有包，只保留公共发布包
    }
  })

/**
 * 判断给定的包名是否为 Vue.js 核心包
 * 用于确定是否需要进行版本同步和依赖更新
 *
 * @param {string} pkgName - 要检查的包名
 * @returns {boolean} 是否为核心包
 */
const isCorePackage = (/** @type {string} */ pkgName) => {
  if (!pkgName) return

  // vue 主包和兼容包始终被视为核心包
  if (pkgName === 'vue' || pkgName === '@vue/compat') {
    return true
  }

  // 检查是否为 @vue/ 作用域下的包，并且在 packages 列表中
  return (
    pkgName.startsWith('@vue') &&
    packages.includes(pkgName.replace(/^@vue\//, ''))
  )
}

/**
 * 将包名转换为 Canary 版本的包名
 * Canary 版本使用不同的包名以避免与正式版本冲突
 *
 * @param {string} pkgName - 原始包名
 * @returns {string} Canary 版本的包名
 */
const renamePackageToCanary = (/** @type {string} */ pkgName) => {
  // vue 主包 -> @vue/canary
  if (pkgName === 'vue') {
    return '@vue/canary'
  }

  // 其他核心包添加 -canary 后缀
  if (isCorePackage(pkgName)) {
    return `${pkgName}-canary`
  }

  // 非核心包保持原名
  return pkgName
}

/**
 * 保持包名不变的函数
 * 用于正式版本发布时的包名处理
 *
 * @param {string} pkgName - 包名
 * @returns {string} 原始包名
 */
const keepThePackageName = (/** @type {string} */ pkgName) => pkgName

// 记录跳过发布的包列表（用于最终报告）
/** @type {string[]} */
const skippedPackages = []

// 定义支持的版本递增类型
// 根据是否存在预发布标识符动态包含预发布选项
/** @type {ReadonlyArray<import('semver').ReleaseType>} */
const versionIncrements = [
  'patch', // 补丁版本：1.0.0 -> 1.0.1
  'minor', // 次要版本：1.0.0 -> 1.1.0
  'major', // 主要版本：1.0.0 -> 2.0.0
  ...(preId
    ? // 如果有预发布标识符，添加预发布选项
      /** @type {const} */ (['prepatch', 'preminor', 'premajor', 'prerelease'])
    : []),
]

/**
 * 根据给定的递增类型计算新版本号
 *
 * @param {import('semver').ReleaseType} i - 版本递增类型
 * @returns {string|null} 新版本号
 */
const inc = (/** @type {import('semver').ReleaseType} */ i) =>
  semver.inc(currentVersion, i, typeof preId === 'string' ? preId : undefined)

/**
 * 执行命令行程序的包装函数
 * 默认继承父进程的 stdio，显示实时输出
 *
 * @param {string} bin - 要执行的程序名
 * @param {ReadonlyArray<string>} args - 命令参数
 * @param {import('node:child_process').SpawnOptions} opts - 执行选项
 */
const run = async (
  /** @type {string} */ bin,
  /** @type {ReadonlyArray<string>} */ args,
  /** @type {import('node:child_process').SpawnOptions} */ opts = {},
) => exec(bin, args, { stdio: 'inherit', ...opts })

/**
 * 干运行模式的命令执行函数
 * 只打印将要执行的命令，不实际执行
 *
 * @param {string} bin - 要执行的程序名
 * @param {ReadonlyArray<string>} args - 命令参数
 * @param {import('node:child_process').SpawnOptions} opts - 执行选项
 */
const dryRun = async (
  /** @type {string} */ bin,
  /** @type {ReadonlyArray<string>} */ args,
  /** @type {import('node:child_process').SpawnOptions} */ opts = {},
) => console.log(pico.blue(`[dryrun] ${bin} ${args.join(' ')}`), opts)

// 根据干运行标志选择实际执行函数
const runIfNotDry = isDryRun ? dryRun : run

/**
 * 获取指定包的根目录路径
 *
 * @param {string} pkg - 包名
 * @returns {string} 包的根目录绝对路径
 */
const getPkgRoot = (/** @type {string} */ pkg) =>
  path.resolve(__dirname, '../packages/' + pkg)

/**
 * 打印发布流程步骤信息
 * 使用青色文字突出显示步骤标题
 *
 * @param {string} msg - 步骤消息
 */
const step = (/** @type {string} */ msg) => console.log(pico.cyan(msg))

/**
 * 主要发布流程函数
 * 协调整个版本发布过程，包括版本选择、测试、构建、发布等所有环节
 */
async function main() {
  // 首先检查本地代码是否与远程仓库同步
  if (!(await isInSyncWithRemote())) {
    return
  } else {
    console.log(`${pico.green(`✓`)} commit is up-to-date with remote.\n`)
  }

  // 从命令行参数获取目标版本号（如果有的话）
  let targetVersion = positionals[0]

  // Canary 版本特殊处理：生成基于日期的版本号
  if (isCanary) {
    // Canary 版本格式：3.yyyyMMdd.0（或 3.yyyyMMdd.0-minor.0 用于 minor 标签）
    // 使用 UTC 时间确保 CI 和开发者机器上的一致性
    const date = new Date()
    const yyyy = date.getUTCFullYear()
    const MM = (date.getUTCMonth() + 1).toString().padStart(2, '0')
    const dd = date.getUTCDate().toString().padStart(2, '0')

    const major = semver.major(currentVersion)
    const datestamp = `${yyyy}${MM}${dd}`
    let canaryVersion

    // 生成基础的 Canary 版本号
    canaryVersion = `${major}.${datestamp}.0`
    if (args.tag && args.tag !== 'latest') {
      canaryVersion = `${major}.${datestamp}.0-${args.tag}.0`
    }

    // 检查 registry 避免版本冲突
    // 以防同一天需要发布多个 Canary 版本
    try {
      const pkgName = renamePackageToCanary('vue')
      const { stdout } = await run(
        'pnpm',
        ['view', `${pkgName}@~${canaryVersion}`, 'version', '--json'],
        { stdio: 'pipe' },
      )
      let versions = JSON.parse(/** @type {string} */ (stdout))
      versions = Array.isArray(versions) ? versions : [versions]

      // 找到同一天已发布的最新补丁版本
      const latestSameDayPatch = /** @type {string} */ (
        semver.maxSatisfying(versions, `~${canaryVersion}`)
      )

      // 基于已存在的版本递增
      canaryVersion = /** @type {string} */ (
        semver.inc(latestSameDayPatch, 'patch')
      )
      if (args.tag && args.tag !== 'latest') {
        canaryVersion = /** @type {string} */ (
          semver.inc(latestSameDayPatch, 'prerelease', args.tag)
        )
      }
    } catch (/** @type {any} */ e) {
      if (/E404/.test(e.message)) {
        // 404 错误表示这是当天的第一个补丁版本，使用默认版本
      } else {
        throw e
      }
    }

    targetVersion = canaryVersion
  }

  // 如果没有明确指定版本号，提供交互式选择
  if (!targetVersion) {
    /** @type {{ release: string }} */
    const { release } = await prompt({
      type: 'select',
      name: 'release',
      message: 'Select release type',
      choices: versionIncrements
        .map(i => `${i} (${inc(i)})`) // 显示版本类型和对应的新版本号
        .concat(['custom']), // 添加自定义版本选项
    })

    if (release === 'custom') {
      // 用户选择自定义版本，提示输入
      /** @type {{ version: string }} */
      const result = await prompt({
        type: 'input',
        name: 'version',
        message: 'Input custom version',
        initial: currentVersion,
      })
      targetVersion = result.version
    } else {
      // 从选择的版本类型中提取版本号（从括号中提取）
      targetVersion = release.match(/\((.*)\)/)?.[1] ?? ''
    }
  }

  // 如果目标版本是版本递增类型名称，计算实际版本号
  // @ts-expect-error
  if (versionIncrements.includes(targetVersion)) {
    // @ts-expect-error
    targetVersion = inc(targetVersion)
  }

  // 验证版本号的有效性
  if (!semver.valid(targetVersion)) {
    throw new Error(`invalid target version: ${targetVersion}`)
  }

  // 显示发布信息或请求确认
  if (skipPrompts) {
    // 跳过提示模式，直接显示发布信息
    step(
      isCanary
        ? `Releasing canary version v${targetVersion}...`
        : `Releasing v${targetVersion}...`,
    )
  } else {
    // 请求用户确认发布
    /** @type {{ yes: boolean }} */
    const { yes: confirmRelease } = await prompt({
      type: 'confirm',
      name: 'yes',
      message: `Releasing v${targetVersion}. Confirm?`,
    })

    if (!confirmRelease) {
      return
    }
  }

  await runTestsIfNeeded()

  // update all package versions and inter-dependencies
  step('\nUpdating cross dependencies...')
  updateVersions(
    targetVersion,
    isCanary ? renamePackageToCanary : keepThePackageName,
  )
  versionUpdated = true

  // generate changelog
  step('\nGenerating changelog...')
  await run(`pnpm`, ['run', 'changelog'])

  if (!skipPrompts) {
    /** @type {{ yes: boolean }} */
    const { yes: changelogOk } = await prompt({
      type: 'confirm',
      name: 'yes',
      message: `Changelog generated. Does it look good?`,
    })

    if (!changelogOk) {
      return
    }
  }

  // update pnpm-lock.yaml
  // skipped during canary release because the package names changed and installing with `workspace:*` would fail
  if (!isCanary) {
    step('\nUpdating lockfile...')
    await run(`pnpm`, ['install', '--prefer-offline'])
  }

  if (!skipGit) {
    const { stdout } = await run('git', ['diff'], { stdio: 'pipe' })
    if (stdout) {
      step('\nCommitting changes...')
      await runIfNotDry('git', ['add', '-A'])
      await runIfNotDry('git', ['commit', '-m', `release: v${targetVersion}`])
    } else {
      console.log('No changes to commit.')
    }
  }

  // publish packages
  if (args.publish) {
    await buildPackages()
    await publishPackages(targetVersion)
  }

  // push to GitHub
  if (!skipGit) {
    step('\nPushing to GitHub...')
    await runIfNotDry('git', ['tag', `v${targetVersion}`])
    await runIfNotDry('git', ['push', 'origin', `refs/tags/v${targetVersion}`])
    await runIfNotDry('git', ['push'])
  }

  if (!args.publish) {
    console.log(
      pico.yellow(
        '\nRelease will be done via GitHub Actions.\n' +
          'Check status at https://github.com/vuejs/core/actions/workflows/release.yml',
      ),
    )
  }

  if (isDryRun) {
    console.log(`\nDry run finished - run git diff to see package changes.`)
  }

  if (skippedPackages.length) {
    console.log(
      pico.yellow(
        `The following packages are skipped and NOT published:\n- ${skippedPackages.join(
          '\n- ',
        )}`,
      ),
    )
  }
  console.log()
}

/**
 * 智能测试执行函数
 * 根据 CI 状态和用户配置决定是否需要运行本地测试
 * 优先检查 CI 状态，如果 CI 通过则可跳过本地测试
 */
async function runTestsIfNeeded() {
  if (!skipTests) {
    step('Checking CI status for HEAD...')
    let isCIPassed = await getCIResult()
    skipTests ||= isCIPassed

    if (isCIPassed) {
      // CI 已通过，询问是否跳过本地测试
      if (!skipPrompts) {
        /** @type {{ yes: boolean }} */
        const { yes: promptSkipTests } = await prompt({
          type: 'confirm',
          name: 'yes',
          message: `CI for this commit passed. Skip local tests?`,
        })
        skipTests = promptSkipTests
      } else {
        // 跳过提示模式，直接跳过测试
        skipTests = true
      }
    } else if (skipPrompts) {
      // CI 未通过且跳过提示模式，抱错退出
      throw new Error(
        'CI for the latest commit has not passed yet. ' +
          'Only run the release workflow after the CI has passed.',
      )
    }
  }

  // 执行测试或跳过
  if (!skipTests) {
    step('\nRunning tests...')
    if (!isDryRun) {
      await run('pnpm', ['run', 'test', '--run'])
    } else {
      console.log(`Skipped (dry run)`)
    }
  } else {
    step('Tests skipped.')
  }
}

/**
 * 获取当前提交的 CI 状态
 * 通过 GitHub API 检查当前 commit 的 CI 流水线是否成功
 *
 * @returns {Promise<boolean>} CI 是否通过
 */
async function getCIResult() {
  try {
    const sha = await getSha()
    // 查询 GitHub Actions API 获取成功的工作流运行
    const res = await fetch(
      `https://api.github.com/repos/vuejs/core/actions/runs?head_sha=${sha}` +
        `&status=success&exclude_pull_requests=true`,
    )
    /** @type {{ workflow_runs: ({ name: string, conclusion: string })[] }} */
    const data = await res.json()

    // 检查是否有名为 'ci' 且结论为 'success' 的工作流
    return data.workflow_runs.some(({ name, conclusion }) => {
      return name === 'ci' && conclusion === 'success'
    })
  } catch {
    console.error('Failed to get CI status for current commit.')
    return false
  }
}

/**
 * 检查本地代码是否与远程仓库同步
 * 通过比较本地和远程的 commit SHA 来确认同步状态
 *
 * @returns {Promise<boolean>} 是否与远程同步
 */
async function isInSyncWithRemote() {
  try {
    const branch = await getBranch()
    // 获取远程分支的最新提交
    const res = await fetch(
      `https://api.github.com/repos/vuejs/core/commits/${branch}?per_page=1`,
    )
    const data = await res.json()

    if (data.sha === (await getSha())) {
      // 本地和远程 commit SHA 一致
      return true
    } else {
      // 本地落后于远程，询问用户是否继续
      /** @type {{ yes: boolean }} */
      const { yes } = await prompt({
        type: 'confirm',
        name: 'yes',
        message: pico.red(
          `Local HEAD is not up-to-date with remote. Are you sure you want to continue?`,
        ),
      })
      return yes
    }
  } catch {
    console.error(
      pico.red('Failed to check whether local HEAD is up-to-date with remote.'),
    )
    return false
  }
}

/**
 * 获取当前 Git 提交的 SHA
 *
 * @returns {Promise<string>} 当前 commit 的 SHA 值
 */
async function getSha() {
  return (await exec('git', ['rev-parse', 'HEAD'])).stdout
}

/**
 * 获取当前 Git 分支名
 *
 * @returns {Promise<string>} 当前分支名
 */
async function getBranch() {
  return (await exec('git', ['rev-parse', '--abbrev-ref', 'HEAD'])).stdout
}

/**
 * 更新所有包的版本号和相互依赖
 * 包括根目录和所有子包的 package.json 文件
 *
 * @param {string} version - 目标版本号
 * @param {(pkgName: string) => string} getNewPackageName - 包名转换函数（用于 Canary 版本）
 */
function updateVersions(version, getNewPackageName = keepThePackageName) {
  // 1. 更新根目录的 package.json
  updatePackage(path.resolve(__dirname, '..'), version, getNewPackageName)

  // 2. 更新所有子包的 package.json
  packages.forEach(p =>
    updatePackage(getPkgRoot(p), version, getNewPackageName),
  )
}

/**
 * 更新单个包的版本信息
 * 包括包名、版本号和相关依赖版本
 *
 * @param {string} pkgRoot - 包的根目录路径
 * @param {string} version - 目标版本号
 * @param {(pkgName: string) => string} getNewPackageName - 包名转换函数
 */
function updatePackage(pkgRoot, version, getNewPackageName) {
  const pkgPath = path.resolve(pkgRoot, 'package.json')
  /** @type {Package} */
  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))

  // 更新包名和版本号
  pkg.name = getNewPackageName(pkg.name)
  pkg.version = version

  // 如果是 Canary 版本，还需要更新依赖包的名称和版本
  if (isCanary) {
    updateDeps(pkg, 'dependencies', version, getNewPackageName)
    updateDeps(pkg, 'peerDependencies', version, getNewPackageName)
  }

  // 写回文件，保持 JSON 格式化
  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
}

/**
 * 更新包的依赖版本
 * 只更新 Vue.js 核心包的依赖，确保版本同步
 *
 * @param {Package} pkg - 包配置对象
 * @param {'dependencies' | 'peerDependencies'} depType - 依赖类型
 * @param {string} version - 目标版本号
 * @param {(pkgName: string) => string} getNewPackageName - 包名转换函数
 */
function updateDeps(pkg, depType, version, getNewPackageName) {
  const deps = pkg[depType]
  if (!deps) return

  Object.keys(deps).forEach(dep => {
    // 只处理 Vue.js 核心包的依赖
    if (isCorePackage(dep)) {
      const newName = getNewPackageName(dep)

      // 如果包名发生了变化（Canary 版本），使用 npm: 别名语法
      const newVersion = newName === dep ? version : `npm:${newName}@${version}`

      console.log(
        pico.yellow(`${pkg.name} -> ${depType} -> ${dep}@${newVersion}`),
      )
      deps[dep] = newVersion
    }
  })
}

/**
 * 构建所有包
 * 执行 pnpm 构建命令，生成用于发布的产物
 */
async function buildPackages() {
  step('\nBuilding all packages...')

  if (!skipBuild) {
    // 执行完整构建，包括 TypeScript 类型定义
    await run('pnpm', ['run', 'build', '--withTypes'])
  } else {
    console.log(`(skipped)`)
  }
}

/**
 * 发布所有包到 npm registry
 * 遍历所有包并逐个发布，处理各种发布配置
 *
 * @param {string} version - 发布的版本号
 */
async function publishPackages(version) {
  step('\nPublishing packages...')

  // 根据不同模式和环境配置发布参数
  const additionalPublishFlags = []

  if (isDryRun) {
    // 干运行模式，不实际发布
    additionalPublishFlags.push('--dry-run')
  }

  if (isDryRun || skipGit || process.env.CI) {
    // 跳过 Git 相关检查（干运行、跳过Git或CI环境）
    additionalPublishFlags.push('--no-git-checks')
  }

  // 在 CI 中发布正式版本时添加源头元数据
  // Canary 版本不提交到 Git，所以不需要 provenance
  // 非正式 npm registry 也跳过 provenance
  if (process.env.CI && !isCanary && !args.registry) {
    additionalPublishFlags.push('--provenance')
  }

  // 遍历所有包并逐个发布
  for (const pkg of packages) {
    await publishPackage(pkg, version, additionalPublishFlags)
  }
}

/**
 * 发布单个包到 npm
 * 处理包的发布标签、跳过逃辑和错误处理
 *
 * @param {string} pkgName - 包名
 * @param {string} version - 版本号
 * @param {ReadonlyArray<string>} additionalFlags - 附加发布参数
 */
async function publishPackage(pkgName, version, additionalFlags) {
  // 检查是否在跳过列表中
  if (skippedPackages.includes(pkgName)) {
    return
  }

  // 根据版本号或参数确定 npm 发布标签
  let releaseTag = null
  if (args.tag) {
    // 使用明确指定的标签
    releaseTag = args.tag
  } else if (version.includes('alpha')) {
    releaseTag = 'alpha'
  } else if (version.includes('beta')) {
    releaseTag = 'beta'
  } else if (version.includes('rc')) {
    releaseTag = 'rc'
  }
  // 没有特殊标识的版本使用默认的 latest 标签

  step(`Publishing ${pkgName}...`)

  try {
    // 使用 pnpm publish 命令发布包
    // 保持使用 pnpm 以正确处理 workspace:* 依赖
    await run(
      'pnpm',
      [
        'publish',
        ...(releaseTag ? ['--tag', releaseTag] : []), // 发布标签
        '--access',
        'public', // 公开发布
        ...(args.registry ? ['--registry', args.registry] : []), // 自定义 registry
        ...additionalFlags, // 其他附加参数
      ],
      {
        cwd: getPkgRoot(pkgName), // 在包目录中执行
        stdio: 'pipe', // 捕获输出以便错误处理
      },
    )

    console.log(pico.green(`Successfully published ${pkgName}@${version}`))
  } catch (/** @type {any} */ e) {
    // 处理发布错误
    if (e.message?.match(/previously published/)) {
      // 包已经发布过，跳过
      console.log(pico.red(`Skipping already published: ${pkgName}`))
    } else {
      // 其他错误，重新抛出
      throw e
    }
  }
}

/**
 * 仅执行发布操作的函数
 * 跳过版本选择、测试、Git 操作等步骤，直接执行构建和发布
 */
async function publishOnly() {
  const targetVersion = positionals[0]

  if (targetVersion) {
    // 如果指定了版本号，更新所有包的版本
    updateVersions(targetVersion)
  }

  // 执行构建和发布
  await buildPackages()
  await publishPackages(currentVersion)
}

// 根据命令行参数选择要执行的主函数
const fnToRun = args.publishOnly ? publishOnly : main

// 执行主函数，并处理全局错误
fnToRun().catch(err => {
  if (versionUpdated) {
    // 如果已经更新了版本但发布失败，进行版本回滚
    updateVersions(currentVersion)
  }
  console.error(err)
  process.exit(1)
})
